# 作者：詹广权
# 版权所有：www.cdsjcc.cn/su-xz
# 说明：通用参数设置模块
# 功能：管理和存储插件各功能模块的参数设置，提供统一的设置界面。

require 'json'

module SuXZ
  module CS
    # 配置文件路径
    CONFIG_FILE = File.join(File.dirname(__FILE__), 'cs.conf')
    
    # 参数映射关系
    PARAM_MAPPING = {
    }
    
    # 存储所有模块的设置
    @all_settings = {}
    
    # 默认设置
    @defaults = {
      'KC' => {
        'depth' => 5.mm,
        'width' => 2.mm,
        'position' => "左边",
        'inward' => true
      }
    }
    
    # 参数定义（用于生成对话框）
    @param_definitions = {
      'KC' => {
        'depth' => {
          'prompt' => "凹槽深度 (mm):",
          'type' => 'length',
          'list' => ""
        },
        'width' => {
          'prompt' => "凹槽宽度 (mm):",
          'type' => 'length',
          'list' => ""
        },
        'position' => {
          'prompt' => "凹槽位置:",
          'type' => 'list',
          'list' => "左边|右边|中间"
        },
        'inward' => {
          'prompt' => "朝向:",
          'type' => 'list',
          'list' => "向内|向外",
          'converter' => lambda { |value| value == "向内" }
        }
      }
    }
    
    # 对话框标题
    @dialog_titles = {
      'KC' => "参数设置"
      # 统一使用"参数设置"作为标题
    }
    
    # 初始化设置
    def self.initialize_settings
      @defaults.each do |module_name, default_settings|
        @all_settings[module_name] ||= default_settings.clone
      end
    end
    
    # 获取指定模块的所有设置
    def self.get_settings(module_name)
      initialize_settings unless @all_settings[module_name]
      return @all_settings[module_name]
    end
    
    # 获取指定模块的特定设置
    def self.get_setting(module_name, setting_name)
      # 检查是否需要映射
      if PARAM_MAPPING[module_name] && PARAM_MAPPING[module_name][setting_name]
        # 获取映射目标
        target_module, target_setting = PARAM_MAPPING[module_name][setting_name]
        # 获取目标模块的设置
        target_settings = get_settings(target_module)
        # 返回映射后的设置值
        return target_settings[target_setting]
      else
        # 正常获取设置
        settings = get_settings(module_name)
        return settings[setting_name]
      end
    end
    
    # 保存指定模块的所有设置
    def self.save_settings(module_name, settings_hash)
      @all_settings[module_name] = settings_hash
      
      puts "保存#{module_name}设置: #{settings_hash.inspect}"
      # 同步保存到配置文件
      save_config
      return @all_settings[module_name]
    end
    
    # 显示指定模块的设置对话框
    def self.show_settings_dialog(module_name = 'KC')
      # 总是使用KC模块的设置对话框
      module_name = 'KC'
      
      # 确保设置已初始化
      settings = get_settings(module_name)
      param_defs = @param_definitions[module_name]
      
      return false unless settings && param_defs
      
      # 准备对话框参数
      prompts = []
      defaults = []
      lists = []
      
      # 按照参数定义顺序构建对话框
      param_defs.each do |param_name, param_def|
        prompts << param_def['prompt']
        
        # 处理特殊类型的参数（如布尔值转换为文本）
        if param_def['type'] == 'list' && param_def['converter']
          if param_def['converter'].is_a?(Proc)
            # 反向转换，从布尔值到显示文本
            if settings[param_name] == true
              defaults << "向内"
            else
              defaults << "向外"
            end
          else
            defaults << settings[param_name].to_s
          end
        else
          defaults << settings[param_name]
        end
        
        lists << param_def['list']
      end
      
      # 显示对话框
      title = @dialog_titles[module_name] || "参数设置"
      input = UI.inputbox(prompts, defaults, lists, title)
      
      if input
        # 更新设置
        new_settings = settings.clone
        
        param_defs.each_with_index do |(param_name, param_def), index|
          value = input[index]
          
          # 根据参数类型处理输入值
          case param_def['type']
          when 'length'
            new_settings[param_name] = value.to_l
          when 'list'
            if param_def['converter'] && param_def['converter'].is_a?(Proc)
              # 使用转换器处理值（如从文本到布尔值）
              new_settings[param_name] = param_def['converter'].call(value)
            else
              new_settings[param_name] = value
            end
          else
            new_settings[param_name] = value
          end
        end
        
        # 保存新设置
        save_settings(module_name, new_settings)
        return true
      else
        return false
      end
    end
    
    # 初始化
    def self.init
      puts "参数设置模块已加载"
      # 尝试从配置文件加载设置，如果失败则使用默认设置
      unless load_config
        initialize_settings
      end
      puts "参数设置初始化完成"
    end
    
    # 从配置文件加载设置
    def self.load_config
      if File.exist?(CONFIG_FILE)
        begin
          puts "发现配置文件，正在读取..."
          config_data = File.read(CONFIG_FILE)
          loaded_settings = JSON.parse(config_data)
          @all_settings = loaded_settings
          puts "成功从配置文件加载设置"
          return true
        rescue => e
          puts "读取配置文件出错: #{e.message}"
          puts "将使用默认设置"
          return false
        end
      else
        puts "未找到配置文件，将使用默认设置"
        # 使用默认设置并创建配置文件
        initialize_settings
        save_config
        return false
      end
    end
    
    # 保存设置到配置文件
    def self.save_config
      begin
        puts "正在保存设置到配置文件..."
        File.open(CONFIG_FILE, 'w') do |file|
          file.write(JSON.pretty_generate(@all_settings))
        end
        puts "设置已保存到配置文件: #{CONFIG_FILE}"
        return true
      rescue => e
        puts "保存配置文件出错: #{e.message}"
        return false
      end
    end
  end
  
  # 初始化CS模块
  CS.init
end